home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / lang / c / c-bat-0.1n / c-bat-0 / c-bat-0.1 / src / clients.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-06-16  |  43.1 KB  |  1,661 lines

  1. /*
  2.     clients.c : Browsing an Analysis Tool for C-source code;
  3.             Client-Application-Library
  4.  
  5.     Copyright (C) 1993  Eckehard Stolz
  6.  
  7.     This program is free software; you can redistribute it and/or modify
  8.     it under the terms of the GNU General Public License as published by
  9.     the Free Software Foundation (version 2 of the License).
  10.  
  11.     This program is distributed in the hope that it will be useful,
  12.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.     GNU General Public License for more details.
  15.  
  16.     You should have received a copy of the GNU General Public License
  17.     along with this program; if not, write to the Free Software
  18.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  */
  20.  
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <string.h>
  24.  
  25. #include "hash.h"
  26. #include "c-bat.h"
  27.  
  28. /*********************************************************
  29.  Short overview:
  30.  
  31.  A Client has first to connect to a server to which it
  32.  can send information requests and get the results.
  33.  
  34.  Normally, the functions defined in this module do
  35.  automatically connect to the master-server, which is
  36.  the first (or only) server started. However, a client
  37.  can connect to an other server if it knows it's server-ID.
  38.  
  39.  This ID can be obtained by the get_server_id function
  40.  which asks the master server for the ID of the server
  41.  which processes a special browser file.
  42.  
  43.  Each client can only be connected to one server at a given
  44.  time. However, you can switch to an other server by first 
  45.  disconnect the old one and then connect to the new
  46.  server.
  47.  
  48.  All functions send the request to the server when they are
  49.  called for the first time. If they can return more than
  50.  one return-value, the have to be called multiple times.
  51.  After the last value has been returned, these functions
  52.  return RET_END instead of 0.
  53.  
  54.  For the documentation of the functions, please look in the
  55.  comments preceeding these functions.
  56.  
  57.  ****************************************/
  58.  
  59. static int connected = 0;
  60.  
  61. /* ID of the server to which this client is connected
  62.  */
  63. static int Server_ID = MASTER_ID;
  64.  
  65. /* Timeout in seconds. Default is set to SECONDS_TIMEOUT
  66.    can be overridden if server recommends higher value
  67.  */
  68. extern int  timeout_value;
  69.  
  70. /* connects to server1;
  71.  
  72.    return:  0    ...  O.K.
  73.             else ...  Return-value from server
  74. */
  75. short brs_connect_server(int server_id)
  76. { char   arg1[STRINGSIZE],
  77.          arg2[STRINGSIZE],
  78.          arg3[STRINGSIZE],
  79.          arg4[STRINGSIZE];
  80.   short  ret, flag;
  81.   int    server, t_out_val;
  82.  
  83.    
  84.   if( connected )
  85.     return( 0 );
  86.    
  87.   /* send command to print all functions in project
  88.    */
  89.   send_brs_cmd( server_id, CMD_CONNECT, 0, "", "" );
  90.   ret = get_brs_ret( CMD_CONNECT, &server, &flag, arg1, arg2, arg3, arg4);
  91.   
  92.    
  93.   if( ret != RET_CONNECT )
  94.    { /* Error */
  95.      /* printf("Connection failed: Code: %hd (%s)\n", ret, arg1); */
  96.      return( ret );
  97.     } 
  98.    
  99.   /* Change timeout if server recommends higher value
  100.    */
  101.   t_out_val = atoi( arg1 ); 
  102.   if( t_out_val > timeout_value )
  103.     timeout_value = t_out_val;
  104.    
  105.   connected = 1;
  106.   Server_ID = server_id;
  107.   return( (flag) ? -1 : 0 );
  108. }
  109.  
  110. /* disconnects actual server
  111.  
  112.    A client may only be connected to one server at a time
  113.  
  114. */
  115. void brs_disconnect_server(void)
  116.    
  117.   if( !connected )
  118.     return;
  119.    
  120.   /* send command to print all functions in project
  121.    */
  122.   send_brs_cmd( Server_ID, CMD_RELEASE, 0, "", "" );
  123.   
  124.   connected = 0;
  125.   return;
  126. }
  127.  
  128. /* sends a browser filename to the master and returns
  129.    the ID of the server processing this file
  130.  
  131.    return-value -1 or -2 : Error
  132.  */
  133. int brs_get_server_id(char *browser_file)
  134. { char arg1[STRINGSIZE],
  135.        arg2[STRINGSIZE],
  136.        arg3[STRINGSIZE],
  137.        arg4[STRINGSIZE];
  138.   short  ret, flag;
  139.   int server; 
  140.    
  141.   send_brs_cmd( MASTER_ID, CMD_SERVER_ID, 0, browser_file, "" );
  142.     
  143.   ret = get_brs_ret( CMD_SERVER_ID, &server, &flag, arg1, arg2, arg3, arg4);
  144.   switch( ret )
  145.    { case RET_SERVER_ID:  return( flag );
  146.       
  147.      case RET_ERROR: return( -1 );
  148.      default:        return( -2 );
  149.     }
  150.  }
  151.   
  152.  
  153.  
  154. /* This function kills server. Return-values like connect_server
  155.    return:  0    ...  O.K.
  156.             else ...  Return-value from server
  157.  */
  158. short brs_kill_server(void)
  159. { short erg;
  160.    
  161.   if( erg = brs_connect_server( Server_ID ) )
  162.    { return( erg );
  163.     }
  164.    
  165.   send_brs_cmd( Server_ID, CMD_TERMINATE, 0, "", "" );
  166.    
  167.   return( 0 );
  168.  }
  169.  
  170.  
  171.  
  172. /* This function returns all functions defined in the project.
  173.    strings should be have a size of at least STRINGSIZE Bytes
  174.  
  175.    funct        ...   holds the name of the function,
  176.    file         ...   the file, where the function is defined (or "" if unknown)
  177.    line         ...   the line in the file, where function is defined (if known)
  178.                       linenumber is the first line after the ')' of the arguments
  179.    module       ...   module to which this file belongs to (or "" if not known)
  180.    static_flag  ...   1 if function is static, 0 else
  181.  
  182.    The first time, this function is called, it issues the 
  183.    CMD_FUNCTIONS-command to the server.
  184.    This function should be called with a NULL-pointer in funct
  185.    to reset internal flags if you want to get all functions a
  186.    second time. However, it does a self-reset, it the RET_END-value 
  187.    is returned by the server.
  188.  
  189.    return:  0        ...  O.K., function-info is stored in arguments
  190.             RET_END  ...  No more functions found
  191.             else     ...  error returned by get_brs_ret
  192.                           error-message in funct/file
  193.  */
  194. short brs_get_all_funct( char *funct, char *file, long *line, char *module, short *static_flag)
  195. { int  server;
  196.   char arg1[STRINGSIZE],
  197.        arg2[STRINGSIZE],
  198.        arg3[STRINGSIZE],
  199.        arg4[STRINGSIZE];
  200.   short  ret, flag;
  201.   static short first = 1;
  202.  
  203.   /* NULL-Pointer in funct used for reset this function
  204.    */
  205.   if( !funct )
  206.    { first = 1;
  207.      return( 0 );
  208.     }
  209.        
  210.  
  211.   if( first )    
  212.     { /* First time this function is called: 
  213.          send command to print all functions in project
  214.        */
  215.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  216.        { return( ret );
  217.         }
  218.       
  219.       send_brs_cmd( Server_ID, CMD_FUNCTIONS, 0, "", "" );
  220.       first = 0;
  221.      }
  222.    
  223.   ret = get_brs_ret( CMD_FUNCTIONS, &server, &flag, arg1, arg2, arg3, arg4);
  224.   switch( ret )
  225.    { case RET_FUNCT:
  226.           strcpy( funct, arg1 );
  227.           strcpy( file , arg2 );
  228.           if( arg2[0] )
  229.             *line = atoi( arg3 );
  230.           strcpy( module, arg4 );
  231.           if( static_flag )
  232.             *static_flag = (flag & 0x04) ? 1 : 0;
  233.           break;
  234.          
  235.      case RET_ERROR:
  236.           strcpy( funct, arg1 );
  237.           strcpy( file, arg2 );
  238.           first = 1;
  239.           return(ret);
  240.           break;
  241.       
  242.      case RET_END:
  243.           first = 1;
  244.           return( ret );
  245.           break;
  246.          
  247.      default:
  248.           first = 1;
  249.           return( ret );
  250.           break;
  251.     }
  252.  
  253.   return( 0 );         
  254.   
  255. }
  256.  
  257. /* This function returns all local variables defined in project.
  258.  
  259.    it works like "get_all_funct" !
  260.  */
  261. short brs_get_all_global_vars( char *funct, char *file, long *line, char *module, short *static_flag)
  262. { int  server;
  263.   char arg1[STRINGSIZE],
  264.        arg2[STRINGSIZE],
  265.        arg3[STRINGSIZE],
  266.        arg4[STRINGSIZE];
  267.   short  ret, flag;
  268.   static short first = 1;
  269.  
  270.   /* NULL-Pointer in funct used for reset this function
  271.    */
  272.   if( !funct )
  273.    { first = 1;
  274.      return( 0 );
  275.     }
  276.        
  277.  
  278.   if( first )    
  279.     { /* First time this function is called: 
  280.          send command to print all functions in project
  281.        */
  282.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  283.        { return( ret );
  284.         }
  285.       
  286.       send_brs_cmd( Server_ID, CMD_VARIABLES, 0, "", "" );
  287.       first = 0;
  288.      }
  289.    
  290.   ret = get_brs_ret( CMD_VARIABLES, &server, &flag, arg1, arg2, arg3, arg4);
  291.   switch( ret )
  292.    { case RET_VAR:
  293.           strcpy( funct, arg1 );
  294.           strcpy( file , arg2 );
  295.           if( arg2[0] )
  296.             *line = atoi( arg3 );
  297.           strcpy( module, arg4 );
  298.           if( static_flag )
  299.             *static_flag = (flag & 0x04) ? 1 : 0;
  300.           break;
  301.          
  302.      case RET_ERROR:
  303.           strcpy( funct, arg1 );
  304.           strcpy( file, arg2 );
  305.           first = 1;
  306.           return(ret);
  307.           break;
  308.       
  309.      case RET_END:
  310.           first = 1;
  311.           return( ret );
  312.           break;
  313.          
  314.      default:
  315.           first = 1;
  316.           return( ret );
  317.           break;
  318.     }
  319.  
  320.   return( 0 );         
  321.   
  322. }
  323.  
  324.  
  325. /* This function returns all functions called by a specific
  326.    function
  327.    strings should be have a size of at least STRINGSIZE Bytes
  328.  
  329.    INPUT:
  330.    funct_in     ...   target-function, (just interesting for the first time)
  331.    file_in      ...   file, where target-function is defined (or called: in this
  332.                       case the one with the right scope (global/static) will be
  333.                       taken)
  334.                       may be "", if function is just defined once
  335.    sym_once     ...   if set to 1, every function is just returned once,
  336.                       otherwise every single call will be returned.
  337.  
  338.    OUTPUT 
  339.    (if ret-value is 0:)
  340.    funct        ...   holds the name of the function,
  341.    file         ...   the file, where the function is called
  342.    line         ...   linenumber, where function is called
  343.    module       ...   always ""
  344.    static_flag  ...   1 if function is static, 0 else
  345.  
  346.    (if ret-value if RET_ERROR)
  347.    funct        ...   Error message 1
  348.    file         ...   Error message 2 (might be "")
  349.  
  350.  
  351.    The first time, this function is called, it issues the 
  352.    CMD_FUNCTIONS-command to the server.
  353.    This function should be called with a NULL-pointer in funct
  354.    to reset internal flags if you want to get all functions a
  355.    second time. However, it does a self-reset, it the RET_END-value 
  356.    is returned by the server.
  357.  
  358.    return:  0        ...  O.K., function-info is stored in arguments
  359.             RET_END  ...  No more functions found
  360.             else     ...  error returned by get_brs_ret
  361.  */
  362. short brs_get_funct_calls( char *funct_in, char *file_in, short sym_once,
  363.                      char *funct, char *file, long *line, 
  364.                      char *module, short *static_flag)
  365. { int  server;
  366.   char arg1[STRINGSIZE],
  367.        arg2[STRINGSIZE],
  368.        arg3[STRINGSIZE],
  369.        arg4[STRINGSIZE];
  370.   short  ret, flag;
  371.   static short first = 1;
  372.  
  373.   /* NULL-Pointer in funct used for reset this function
  374.    */
  375.   if( !funct_in )
  376.    { first = 1;
  377.      return( 0 );
  378.     }
  379.        
  380.  
  381.   if( first )    
  382.     { /* First time this function is called: 
  383.          send command to print all functions in project
  384.        */
  385.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  386.        { return( ret );
  387.         }
  388.       
  389.       send_brs_cmd( Server_ID, (sym_once) ? CMD_CALLS_ONCE : CMD_CALLS, 
  390.                     0, funct_in, file_in );
  391.       first = 0;
  392.      }
  393.    
  394.   ret = get_brs_ret( (sym_once) ? CMD_CALLS_ONCE : CMD_CALLS,
  395.                      &server, &flag, arg1, arg2, arg3, arg4);
  396.   switch( ret )
  397.    { case RET_FUNCT:
  398.           strcpy( funct, arg1 );
  399.           strcpy( file , arg2 );
  400.           if( arg2[0] )
  401.             *line = atoi( arg3 );
  402.           strcpy( module, arg4 );
  403.           if( static_flag )
  404.             *static_flag = (flag & 0x04) ? 1 : 0;
  405.           break;
  406.  
  407.      case RET_ERROR:
  408.           strcpy( funct, arg1 );
  409.           strcpy( file, arg2 );
  410.           first = 1;
  411.           return(ret);
  412.           break;
  413.  
  414.      case RET_END:
  415.           first = 1;
  416.           return( ret );
  417.           break;
  418.          
  419.      default:
  420.           first = 1;
  421.           return( ret );
  422.           break;
  423.     }
  424.  
  425.   return( 0 );         
  426.   
  427. }
  428.  
  429. /* This function gets all global variables that are used
  430.    by the given function.
  431.  
  432.    It works like "get_funct_calls", so see above
  433.    for dokumentation.
  434.  */
  435. short brs_get_var_uses( char *funct_in, char *file_in, short sym_once,
  436.                      char *var, char *file, long *line, 
  437.                      char *module, short *static_flag)
  438. { int  server;
  439.   char arg1[STRINGSIZE],
  440.        arg2[STRINGSIZE],
  441.        arg3[STRINGSIZE],
  442.        arg4[STRINGSIZE];
  443.   short  ret, flag;
  444.   static short first = 1;
  445.  
  446.   /* NULL-Pointer in funct used for reset this function
  447.    */
  448.   if( !funct_in )
  449.    { first = 1;
  450.      return( 0 );
  451.     }
  452.        
  453.  
  454.   if( first )    
  455.     { /* First time this function is called: 
  456.          send command to print all functions in project
  457.        */
  458.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  459.        { return( ret );
  460.         }
  461.       
  462.       send_brs_cmd( Server_ID, (sym_once) ? CMD_USES_ONCE : CMD_USES, 
  463.                     0, funct_in, file_in );
  464.       first = 0;
  465.      }
  466.    
  467.   ret = get_brs_ret( (sym_once) ? CMD_USES_ONCE : CMD_USES, 
  468.                      &server, &flag, arg1, arg2, arg3, arg4);
  469.   switch( ret )
  470.    { case RET_VAR:
  471.           strcpy( var, arg1 );
  472.           strcpy( file , arg2 );
  473.           if( arg2[0] )
  474.             *line = atoi( arg3 );
  475.           strcpy( module, arg4 );
  476.           if( static_flag )
  477.             *static_flag = (flag & 0x04) ? 1 : 0;
  478.           break;
  479.  
  480.      case RET_ERROR:
  481.           strcpy( var, arg1 );
  482.           strcpy( file, arg2 );
  483.           first = 1;
  484.           return(ret);
  485.           break;
  486.  
  487.      case RET_END:
  488.           first = 1;
  489.           return( ret );
  490.           break;
  491.          
  492.      default:
  493.           first = 1;
  494.           return( ret );
  495.           break;
  496.     }
  497.  
  498.   return( 0 );         
  499.   
  500. }
  501.  
  502.  
  503. /* This function returns every function, that calls the specific
  504.    function
  505.    strings should be have a size of at least STRINGSIZE Bytes
  506.  
  507.    INPUT:
  508.    funct_in     ...   target-function, (just interesting for the first time)
  509.    file_in      ...   file, where target-function is defined (or called: in this
  510.                       case the one with the right scope (global/static) will be
  511.                       taken).
  512.                       may be "", if function is just defined once
  513.    sym_once     ...   if set to 1, every function is just returned once,
  514.                       otherwise every single call will be returned.
  515.  
  516.    OUTPUT 
  517.    (if ret-value is 0:)
  518.    funct        ...   holds the name of the function,
  519.    file         ...   the file, where the target-function is called
  520.    line         ...   linenumber, where target-function is called
  521.    module       ...   always ""
  522.    static_flag  ...   1 if function is static, 0 else
  523.  
  524.    (if ret-value if RET_ERROR)
  525.    funct        ...   Error message 1
  526.    file         ...   Error message 2 (might be "")
  527.  
  528.  
  529.    The first time, this function is called, it issues the 
  530.    CMD_...-command to the server.
  531.    This function should be called with a NULL-pointer in funct
  532.    to reset internal flags if you want to get all functions a
  533.    second time. However, it does a self-reset, it the RET_END-value 
  534.    is returned by the server.
  535.  
  536.    return:  0        ...  O.K., function-info is stored in arguments
  537.             RET_END  ...  No more functions found
  538.             else     ...  error returned by get_brs_ret
  539.  */
  540. short brs_get_funct_called_by( char *funct_in, char *file_in, short sym_once,
  541.                      char *funct, char *file, long *line, 
  542.                      char *module, short *static_flag)
  543. { int  server;
  544.   char arg1[STRINGSIZE],
  545.        arg2[STRINGSIZE],
  546.        arg3[STRINGSIZE],
  547.        arg4[STRINGSIZE];
  548.   short  ret, flag;
  549.   static short first = 1;
  550.  
  551.   /* NULL-Pointer in funct used for reset this function
  552.    */
  553.   if( !funct_in )
  554.    { first = 1;
  555.      return( 0 );
  556.     }
  557.        
  558.  
  559.   if( first )    
  560.     { /* First time this function is called: 
  561.          send command to print all functions in project
  562.        */
  563.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  564.        { return( ret );
  565.         }
  566.       
  567.       send_brs_cmd( Server_ID, (sym_once) ? CMD_CALLED_BY_ONCE : CMD_CALLED_BY, 
  568.                     0, funct_in, file_in );
  569.       first = 0;
  570.      }
  571.    
  572.   ret = get_brs_ret( (sym_once) ? CMD_CALLED_BY_ONCE : CMD_CALLED_BY,
  573.                      &server, &flag, arg1, arg2, arg3, arg4);
  574.   switch( ret )
  575.    { case RET_FUNCT:
  576.           strcpy( funct, arg1 );
  577.           strcpy( file , arg2 );
  578.           if( arg2[0] )
  579.             *line = atoi( arg3 );
  580.           strcpy( module, arg4 );
  581.           if( static_flag )
  582.             *static_flag = (flag & 0x04) ? 1 : 0;
  583.           break;
  584.  
  585.      case RET_ERROR:
  586.           strcpy( funct, arg1 );
  587.           strcpy( file, arg2 );
  588.           first = 1;
  589.           return(ret);
  590.           break;
  591.  
  592.      case RET_END:
  593.           first = 1;
  594.           return( ret );
  595.           break;
  596.          
  597.      default:
  598.           first = 1;
  599.           return( ret );
  600.           break;
  601.     }
  602.  
  603.   return( 0 );         
  604.   
  605. }
  606.  
  607. /* This function returns every function, that uses the specific
  608.    variable
  609.    strings should be have a size of at least STRINGSIZE Bytes
  610.  
  611.    INPUT:
  612.    var_in       ...   target-variable, (just interesting for the first time)
  613.    file_in      ...   file, where target-variable is defined (or used: in this
  614.                       case the one with the right scope (global/static) will be
  615.                       taken).
  616.                       may be "", if variable is just defined once
  617.    sym_once     ...   if set to 1, every function is just returned once,
  618.                       otherwise every single usage will be returned.
  619.  
  620.    OUTPUT 
  621.    (if ret-value is 0:)
  622.    funct        ...   holds the name of the function,
  623.    file         ...   the file, where the target-variable is used
  624.    line         ...   linenumber, where target-variable is used
  625.    module       ...   always ""
  626.    static_flag  ...   1 if function is static, 0 else
  627.  
  628.    (if ret-value if RET_ERROR)
  629.    funct        ...   Error message 1
  630.    file         ...   Error message 2 (might be "")
  631.  
  632.  
  633.    The first time, this function is called, it issues the 
  634.    CMD_...-command to the server.
  635.    This function should be called with a NULL-pointer in funct
  636.    to reset internal flags if you want to get all functions a
  637.    second time. However, it does a self-reset, it the RET_END-value 
  638.    is returned by the server.
  639.  
  640.    return:  0        ...  O.K., function-info is stored in arguments
  641.             RET_END  ...  No more functions found
  642.             else     ...  error returned by get_brs_ret
  643.  */
  644. short brs_get_var_used_by( char *var_in, char *file_in, short sym_once,
  645.                      char *funct, char *file, long *line, 
  646.                      char *module, short *static_flag)
  647. { int  server;
  648.   char arg1[STRINGSIZE],
  649.        arg2[STRINGSIZE],
  650.        arg3[STRINGSIZE],
  651.        arg4[STRINGSIZE];
  652.   short  ret, flag;
  653.   static short first = 1;
  654.  
  655.   /* NULL-Pointer in funct used for reset this function
  656.    */
  657.   if( !var_in )
  658.    { first = 1;
  659.      return( 0 );
  660.     }
  661.        
  662.  
  663.   if( first )    
  664.     { /* First time this function is called: 
  665.          send command to print all functions in project
  666.        */
  667.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  668.        { return( ret );
  669.         }
  670.       
  671.       send_brs_cmd( Server_ID, (sym_once) ? CMD_USED_BY_ONCE : CMD_USED_BY, 
  672.                     0, var_in, file_in );
  673.       first = 0;
  674.      }
  675.    
  676.   ret = get_brs_ret( (sym_once) ? CMD_USED_BY_ONCE : CMD_USED_BY,
  677.                      &server, &flag, arg1, arg2, arg3, arg4);
  678.   switch( ret )
  679.    { case RET_FUNCT:
  680.           strcpy( funct, arg1 );
  681.           strcpy( file , arg2 );
  682.           if( arg2[0] )
  683.             *line = atoi( arg3 );
  684.           strcpy( module, arg4 );
  685.           if( static_flag )
  686.             *static_flag = (flag & 0x04) ? 1 : 0;
  687.           break;
  688.  
  689.      case RET_ERROR:
  690.           strcpy( funct, arg1 );
  691.           strcpy( file, arg2 );
  692.           first = 1;
  693.           return(ret);
  694.           break;
  695.  
  696.      case RET_END:
  697.           first = 1;
  698.           return( ret );
  699.           break;
  700.          
  701.      default:
  702.           first = 1;
  703.           return( ret );
  704.           break;
  705.     }
  706.  
  707.   return( 0 );         
  708.   
  709. }
  710.  
  711.  
  712. /* This function returns all include-files of a given file.
  713.  
  714.    Every Include is named just once
  715.  
  716.    INPUT:
  717.    file_in      ...   filename of main-file ( xxx.c ), where the browser
  718.                       should look for includes
  719.  
  720.    OUTPUT 
  721.    (if ret-value is 0:)
  722.    file         ...   include-filename
  723.    inc_file     ...   file, where #include-directive was found
  724.                       (may be mainfile or an other headerfile in 
  725.                       case of nested include-levels)
  726.    sys_flag     ...   1 if include-file is a system-header
  727.  
  728.    (if ret-value if RET_ERROR)
  729.    file         ...   Error message 1
  730.    inc_file     ...   Error message 2
  731.  
  732.  
  733.    The first time, this function is called, it issues the 
  734.    CMD_FUNCTIONS-command to the server.
  735.    This function should be called with a NULL-pointer in funct
  736.    to reset internal flags if you want to get all functions a
  737.    second time. However, it does a self-reset, it the RET_END-value 
  738.    is returned by the server.
  739.  
  740.  
  741.    return:  0        ...  O.K., function-info is stored in arguments
  742.             RET_END  ...  No more functions found
  743.             else     ...  error returned by get_brs_ret
  744.  */
  745. short brs_get_includes(  char *file_in,
  746.                      char *file, char *inc_file, short *sys_flag)
  747. { int  server;
  748.   char arg1[STRINGSIZE],
  749.        arg2[STRINGSIZE],
  750.        arg3[STRINGSIZE],
  751.        arg4[STRINGSIZE];
  752.   short  ret, flag;
  753.   static short first = 1;
  754.  
  755.   /* NULL-Pointer in funct used for reset this function
  756.    */
  757.   if( !file_in )
  758.    { first = 1;
  759.      return( 0 );
  760.     }
  761.        
  762.  
  763.   if( first )    
  764.     { /* First time this function is called: 
  765.          send command to print all functions in project
  766.        */
  767.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  768.        { return( ret );
  769.         }
  770.       
  771.       send_brs_cmd( Server_ID, CMD_INCLUDES, 0, file_in, "" );
  772.       first = 0;
  773.      }
  774.    
  775.   ret = get_brs_ret( CMD_INCLUDES, &server, &flag, arg1, arg2, arg3, arg4);
  776.   
  777.   switch( ret )
  778.    { case RET_FILE:
  779.           strcpy( file , arg1 );
  780.           if( arg2[0] )
  781.              strcpy( inc_file , arg2 );
  782.           if( sys_flag )
  783.             *sys_flag = (flag & 0x02) ? 1 : 0;
  784.           break;
  785.  
  786.      case RET_ERROR:
  787.           strcpy( file, arg1 );
  788.           strcpy( inc_file, arg2 );
  789.           first = 1;
  790.           return(ret);
  791.           break;
  792.  
  793.      case RET_END:
  794.           first = 1;
  795.           return( ret );
  796.           break;
  797.          
  798.      default:
  799.           first = 1;
  800.           return( ret );
  801.           break;
  802.     }
  803.  
  804.   return( 0 );         
  805.   
  806. }
  807.  
  808. /* This function returns the position, where a given function
  809.    is defined
  810.  
  811.    INPUT:
  812.    funct_in     ...   target-function
  813.    file_in      ...   file, where target-function is defined (and defined only !)
  814.                       may be "", if function is just defined once
  815.  
  816.    OUTPUT 
  817.    (if ret-value is 0:)
  818.    file         ...   the file, where the function is defined
  819.    line         ...   linenumber, where function is defined
  820.    end_line     ...   linenumber, where function ends
  821.    module       ...   module where file belongs to or ""
  822.  
  823.    (if ret-value if RET_ERROR)
  824.    file         ...   Error message 1
  825.    module       ...   Error message 2 (might be "")
  826.  
  827.  
  828.    return:  0        ...  O.K., function-info is stored in arguments
  829.             else     ...  error returned by get_brs_ret
  830.  */
  831. short brs_get_funct_pos( char *funct_in, char *file_in,
  832.                      char *file, long *line, long *end_line, char *module)
  833. { int  server;
  834.   char arg1[STRINGSIZE],
  835.        arg2[STRINGSIZE],
  836.        arg3[STRINGSIZE],
  837.        arg4[STRINGSIZE];
  838.   short  ret, flag;
  839.  
  840.   /* send command to retrieve position of function
  841.    */
  842.   if( (ret = brs_connect_server( Server_ID )) > 0 )
  843.    { return( ret );
  844.     }
  845.       
  846.   send_brs_cmd( Server_ID, CMD_FUNCT_POS, 0, funct_in, file_in );
  847.    
  848.   ret = get_brs_ret( CMD_FUNCT_POS, &server, &flag, arg1, arg2, arg3, arg4);
  849.   switch( ret )
  850.    { case RET_FPOS:
  851.           strcpy( file , arg1 );
  852.           if( arg2[0] )
  853.             *line = atoi( arg2 );
  854.           if( arg3[0] )
  855.             *end_line = atoi( arg3 );
  856.           strcpy( module, arg4 );
  857.           break;
  858.  
  859.      case RET_ERROR:
  860.           strcpy( file, arg1 );
  861.           strcpy( module, arg2 );
  862.           return(ret);
  863.           break;
  864.  
  865.      case RET_END:
  866.           return( ret );
  867.           break;
  868.          
  869.      default:
  870.           return( ret );
  871.           break;
  872.     }
  873.  
  874.   return( 0 );         
  875.   
  876. }
  877.  
  878. /* This function returns the position where given global variable
  879.    is defined
  880.  
  881.    INPUT:
  882.    var_in       ...   target-variable
  883.    file_in      ...   file, where target-variable is defined (defined only !)
  884.                       may be "", if variable is just defined once
  885.  
  886.    OUTPUT 
  887.    (if ret-value is 0:)
  888.    file         ...   the file, where the variable is defined
  889.    line         ...   linenumber, where variable is defined
  890.    module       ...   module where file belongs to or ""
  891.  
  892.    (if ret-value if RET_ERROR)
  893.    file         ...   Error message 1
  894.    module       ...   Error message 2 (might be "")
  895.  
  896.  
  897.    return:  0        ...  O.K., variable-info is stored in arguments
  898.             else     ...  error returned by get_brs_ret
  899.  */
  900. short brs_get_var_pos( char *var_in, char *file_in,
  901.                      char *file, long *line, char *module)
  902. { int  server;
  903.   char arg1[STRINGSIZE],
  904.        arg2[STRINGSIZE],
  905.        arg3[STRINGSIZE],
  906.        arg4[STRINGSIZE];
  907.   short  ret, flag;
  908.  
  909.   /* send command to retrieve position of function
  910.    */
  911.   if( (ret = brs_connect_server( Server_ID )) > 0 )
  912.    { return( ret );
  913.     }
  914.       
  915.   send_brs_cmd( Server_ID, CMD_VAR_POS, 0, var_in, file_in );
  916.    
  917.   ret = get_brs_ret( CMD_VAR_POS, &server, &flag, arg1, arg2, arg3, arg4);
  918.   switch( ret )
  919.    { case RET_POS:
  920.           strcpy( file , arg1 );
  921.           if( arg2[0] )
  922.             *line = atoi( arg2 );
  923.           strcpy( module, arg3 );
  924.           break;
  925.  
  926.      case RET_ERROR:
  927.           strcpy( file, arg1 );
  928.           strcpy( module, arg2 );
  929.           return(ret);
  930.           break;
  931.  
  932.      case RET_END:
  933.           return( ret );
  934.           break;
  935.          
  936.      default:
  937.           return( ret );
  938.           break;
  939.     }
  940.  
  941.   return( 0 );         
  942.   
  943. }
  944.  
  945.  
  946.  
  947. /* This function tells the browser-engine (server1) to re-init with
  948.    a new browser-file
  949.  
  950.    return value:
  951.    0     ... O.K.
  952.    else  ... Error, if RET_ERROR, in err_msg1 and err_msg2 errormessages 
  953.              from server
  954.  */
  955. short brs_reinit_browser( char *file, char *err_msg1, char *err_msg2)
  956. { int  server;
  957.   char arg1[STRINGSIZE],
  958.        arg2[STRINGSIZE],
  959.        arg3[STRINGSIZE],
  960.        arg4[STRINGSIZE];
  961.   short  ret,
  962.          flag;
  963.   short  erg;
  964.     
  965.   if( (erg = brs_connect_server( Server_ID )) > 0 )
  966.    { return( erg );
  967.     }
  968.    
  969.   /* send command to print all functions in project
  970.    */
  971.   send_brs_cmd( Server_ID, CMD_INIT, 0, file, "" );
  972.   ret = get_brs_ret( CMD_INIT, &server, &flag, arg1, arg2, arg3, arg4);
  973.   switch( ret )
  974.    { case RET_OK:
  975.           ret = 0;
  976.           break;
  977.       
  978.      case RET_ERROR:
  979.           strcpy( err_msg1, arg1);
  980.           strcpy( err_msg2, arg2);
  981.           break;
  982.          
  983.      default:
  984.           break;
  985.     }
  986.    
  987.   return( ret );
  988. }
  989.  
  990.  
  991. /* This function returns all types (structs, unions, typedefs, enums)
  992.    defined in the project.
  993.    strings should be have a size of at least STRINGSIZE Bytes
  994.  
  995.    INPUT: 
  996.    type_code    ...   0 ... structs
  997.                       1 ... unions
  998.                       2 ... enums
  999.                       3 ... typedefs
  1000.  
  1001.    OUTPUT:
  1002.    type_name    ...   holds the name of the type,
  1003.    file         ...   the file, where the type is defined (or "" if unknown)
  1004.    line         ...   the line in the file, where type is defined (if known)
  1005.                       linenumber is the first line after the ')' of the arguments
  1006.  
  1007.  
  1008.    return:  0        ...  O.K., function-info is stored in arguments
  1009.             RET_END  ...  No more functions found
  1010.             else     ...  error returned by get_brs_ret
  1011.                           error-message in funct/file
  1012.  */
  1013. short brs_get_all_types( short type_code, char *type_name, char *file, long *line)
  1014. { int  server;
  1015.   char arg1[STRINGSIZE],
  1016.        arg2[STRINGSIZE],
  1017.        arg3[STRINGSIZE],
  1018.        arg4[STRINGSIZE];
  1019.   short  ret, flag, cmd;
  1020.   static short first = 1;
  1021.  
  1022.   /* NULL-Pointer in funct used for reset this function
  1023.    */
  1024.   if( !type_name )
  1025.    { first = 1;
  1026.      return( 0 );
  1027.     }
  1028.  
  1029.   switch( type_code )
  1030.     { case 0: cmd = CMD_STRUCTS;  break;
  1031.       case 1: cmd = CMD_UNIONS;   break;
  1032.       case 2: cmd = CMD_ENUMS;    break;
  1033.       case 3: cmd = CMD_TYPEDEFS; break;      
  1034.       default: cmd = CMD_STRUCTS; break;
  1035.      }
  1036.  
  1037.   if( first )    
  1038.     { /* First time this function is called: 
  1039.          send command to print all functions in project
  1040.        */
  1041.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  1042.        { return( ret );
  1043.         }
  1044.       
  1045.       send_brs_cmd( Server_ID, cmd, 0, "", "" );
  1046.       first = 0;
  1047.      }
  1048.    
  1049.   ret = get_brs_ret( cmd, &server, &flag, arg1, arg2, arg3, arg4);
  1050.   switch( ret )
  1051.    { case RET_STRUCT:
  1052.      case RET_UNION:
  1053.      case RET_ENUM:
  1054.      case RET_TYPEDEF:
  1055.           strcpy( type_name, arg1 );
  1056.           strcpy( file , arg2 );
  1057.           if( arg2[0] )
  1058.             *line = atoi( arg3 );
  1059.           break;
  1060.          
  1061.      case RET_ERROR:
  1062.           strcpy( type_name, arg1 );
  1063.           strcpy( file, arg2 );
  1064.           first = 1;
  1065.           return(ret);
  1066.           break;
  1067.       
  1068.      case RET_END:
  1069.           first = 1;
  1070.           return( ret );
  1071.           break;
  1072.          
  1073.      default:
  1074.           first = 1;
  1075.           return( ret );
  1076.           break;
  1077.     }
  1078.  
  1079.   return( 0 );         
  1080.   
  1081. }
  1082.  
  1083. /* This function returns the usage of components.
  1084.  
  1085.    INPUT: 
  1086.    type      0   Get all components in a file (or global if arg2 == "")
  1087.              1   Get all component references in a function 
  1088.              2   Get all components in same line like variable
  1089.  
  1090.    component_name  ...   name of the target component of a struct/union
  1091.  
  1092.    arg2          depends on type:  0 ... filename or ""
  1093.                                    1 ... function name
  1094.                                    2 ... variable name
  1095.  
  1096.    OUTPUT:
  1097.    file         ...   the file, where component used
  1098.    line         ...   the line in the file, where component used
  1099.    function     ...   ident of function where component used
  1100.  
  1101.    return:  0        ...  O.K.
  1102.             RET_END  ...  No more items found
  1103.             else     ...  error returned by get_brs_ret
  1104.                           error-message in file/function
  1105.  */
  1106. short brs_get_component_use( int type, char *comp_name, char *f_in, 
  1107.                          char *file, long *line, char *function)
  1108. { int  server;
  1109.   char arg1[STRINGSIZE],
  1110.        arg2[STRINGSIZE],
  1111.        arg3[STRINGSIZE],
  1112.        arg4[STRINGSIZE];
  1113.   short  ret, flag, cmd;
  1114.   static short first = 1;
  1115.  
  1116.   /* NULL-Pointer in funct used for reset this function
  1117.    */
  1118.   if( !comp_name )
  1119.    { first = 1;
  1120.      return( 0 );
  1121.     }
  1122.  
  1123.  
  1124.   if( first )    
  1125.     { /* First time this function is called: 
  1126.          send command to print all functions in project
  1127.        */
  1128.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  1129.        { return( ret );
  1130.         }
  1131.       
  1132.       switch( type )
  1133.         { case 0: 
  1134.              send_brs_cmd( Server_ID, CMD_REFERENCE  , 0, comp_name, f_in );
  1135.              cmd = CMD_REFERENCE;
  1136.              break;
  1137.           case 1: 
  1138.              send_brs_cmd( Server_ID, CMD_REFERENCE_F, 0, comp_name, f_in );
  1139.              cmd = CMD_REFERENCE_F;
  1140.              break;
  1141.           case 2: 
  1142.              send_brs_cmd( Server_ID, CMD_REFERENCE_V, 0, comp_name, f_in );
  1143.              cmd = CMD_REFERENCE_V;
  1144.              break;
  1145.           default: 
  1146.              break;
  1147.          }
  1148.       first = 0;
  1149.      }
  1150.    
  1151.   ret = get_brs_ret( cmd, &server, &flag, arg1, arg2, arg3, arg4);
  1152.   switch( ret )
  1153.    { case RET_REFERENCE:
  1154.           strcpy( file, arg1 );
  1155.           *line = atoi( arg2 );
  1156.           strcpy( function , arg3 );
  1157.           break;
  1158.          
  1159.      case RET_ERROR:
  1160.           strcpy( file, arg1 );
  1161.           strcpy( function, arg3 );
  1162.           first = 1;
  1163.           return(ret);
  1164.           break;
  1165.       
  1166.      case RET_END:
  1167.           first = 1;
  1168.           return( ret );
  1169.           break;
  1170.          
  1171.      default:
  1172.           first = 1;
  1173.           return( ret );
  1174.           break;
  1175.     }
  1176.  
  1177.   return( 0 );         
  1178.   
  1179. }
  1180.  
  1181. /* This function returns all files in a project (just main-files, not the
  1182.    includes)
  1183.    strings should be have a size of at least STRINGSIZE Bytes
  1184.  
  1185.    The first time, this function is called, it issues the 
  1186.    CMD_FILES-command to the server.
  1187.  
  1188.    Return-values:
  1189.  
  1190.      file    ...  filename
  1191.      module  ...  module, where file belongs to
  1192.  
  1193.    return:  0        ...  O.K., function-info is stored in arguments
  1194.             RET_END  ...  No more functions found
  1195.             else     ...  error returned by get_brs_ret
  1196.                           error-message in funct/file
  1197.  */
  1198. short brs_get_all_files( char *file, char *module)
  1199. { int  server;
  1200.   char arg1[STRINGSIZE],
  1201.        arg2[STRINGSIZE],
  1202.        arg3[STRINGSIZE],
  1203.        arg4[STRINGSIZE];
  1204.   short  ret, flag;
  1205.   static short first = 1;
  1206.  
  1207.   /* NULL-Pointer in funct used for reset this function
  1208.    */
  1209.   if( !file )
  1210.    { first = 1;
  1211.      return( 0 );
  1212.     }
  1213.        
  1214.  
  1215.   if( first )    
  1216.     { /* First time this function is called: 
  1217.          send command to print all functions in project
  1218.        */
  1219.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  1220.        { return( ret );
  1221.         }
  1222.       
  1223.       send_brs_cmd( Server_ID, CMD_FILES, 0, "", "" );
  1224.       first = 0;
  1225.      }
  1226.    
  1227.   ret = get_brs_ret( CMD_FILES, &server, &flag, arg1, arg2, arg3, arg4);
  1228.   switch( ret )
  1229.    { case RET_FILE:
  1230.           strcpy( file , arg1 );
  1231.           strcpy( module, arg2 );
  1232.           break;
  1233.          
  1234.      case RET_ERROR:
  1235.           strcpy( file, arg1 );
  1236.           strcpy( module, arg2 );
  1237.           first = 1;
  1238.           return(ret);
  1239.           break;
  1240.       
  1241.      case RET_END:
  1242.           first = 1;
  1243.           return( ret );
  1244.           break;
  1245.          
  1246.      default:
  1247.           first = 1;
  1248.           return( ret );
  1249.           break;
  1250.     }
  1251.  
  1252.   return( 0 );         
  1253.   
  1254. }
  1255.  
  1256.  
  1257. /* This function returns the working directory of a given 
  1258.    source-file
  1259.  
  1260.    INPUT:
  1261.    file_in      ...   source-file
  1262.  
  1263.    OUTPUT 
  1264.    (if ret-value is 0:)
  1265.    dir          ...   working-directory
  1266.  
  1267.    (if ret-value if RET_ERROR)
  1268.    dir          ...   Error message 1
  1269.  
  1270.  
  1271.    return:  0        ...  O.K., working-directory stored
  1272.             else     ...  error returned by get_brs_ret
  1273.  */
  1274. short brs_get_file_dir( char *file_in, char *dir)
  1275. { int  server;
  1276.   char arg1[STRINGSIZE],
  1277.        arg2[STRINGSIZE],
  1278.        arg3[STRINGSIZE],
  1279.        arg4[STRINGSIZE];
  1280.   short  ret, flag;
  1281.  
  1282.   /* send command to retrieve position of function
  1283.    */
  1284.   if( (ret = brs_connect_server( Server_ID )) > 0 )
  1285.    { return( ret );
  1286.     }
  1287.       
  1288.   send_brs_cmd( Server_ID, CMD_WORK_DIR, 0, file_in, "" );
  1289.    
  1290.   ret = get_brs_ret( CMD_WORK_DIR, &server, &flag, arg1, arg2, arg3, arg4);
  1291.   switch( ret )
  1292.    { case RET_DIR:
  1293.           strcpy( dir , arg1 );
  1294.           break;
  1295.  
  1296.      case RET_ERROR:
  1297.           strcpy( dir, arg1 );
  1298.           return(ret);
  1299.           break;
  1300.  
  1301.      case RET_END:
  1302.           return( ret );
  1303.           break;
  1304.          
  1305.      default:
  1306.           return( ret );
  1307.           break;
  1308.     }
  1309.  
  1310.   return( 0 );         
  1311.   
  1312. }
  1313.  
  1314. /* This function returns all macros defined in the project.
  1315.    strings should be have a size of at least STRINGSIZE Bytes
  1316.  
  1317.    macro        ...   holds the name of the macro
  1318.    file         ...   the file, where the macro is defined (or "" if unknown)
  1319.    line         ...   the line in the file, where macro is defined (if known)
  1320.  
  1321.  
  1322.    return:  0        ...  O.K., function-info is stored in arguments
  1323.             RET_END  ...  No more functions found
  1324.             else     ...  error returned by get_brs_ret
  1325.                           error-message in macro/file
  1326.  */
  1327. short brs_get_all_macro( char *macro, char *file, long *line )
  1328. { int  server;
  1329.   char arg1[STRINGSIZE],
  1330.        arg2[STRINGSIZE],
  1331.        arg3[STRINGSIZE],
  1332.        arg4[STRINGSIZE];
  1333.   short  ret, flag;
  1334.   static short first = 1;
  1335.  
  1336.   /* NULL-Pointer in funct used for reset this function
  1337.    */
  1338.   if( !macro )
  1339.    { first = 1;
  1340.      return( 0 );
  1341.     }
  1342.        
  1343.  
  1344.   if( first )    
  1345.     { /* First time this function is called: 
  1346.          send command to print all functions in project
  1347.        */
  1348.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  1349.        { return( ret );
  1350.         }
  1351.       
  1352.       send_brs_cmd( Server_ID, CMD_MACROS, 0, "", "" );
  1353.       first = 0;
  1354.      }
  1355.    
  1356.   do
  1357.    { ret = get_brs_ret( CMD_MACROS, &server, &flag, arg1, arg2, arg3, arg4);
  1358.             
  1359.     } while( !ret );
  1360.   switch( ret )
  1361.    { case RET_MACRO:
  1362.           strcpy( macro, arg1 );
  1363.           strcpy( file , arg2 );
  1364.           if( arg2[0] )
  1365.             *line = atoi( arg3 );
  1366.           break;
  1367.          
  1368.      case RET_ERROR:
  1369.           strcpy( macro, arg1 );
  1370.           strcpy( file, arg2 );
  1371.           first = 1;
  1372.           return(ret);
  1373.           break;
  1374.       
  1375.      case RET_END:
  1376.           first = 1;
  1377.           return( ret );
  1378.           break;
  1379.          
  1380.      default:
  1381.           first = 1;
  1382.           return( ret );
  1383.           break;
  1384.     }
  1385.  
  1386.   return( 0 );         
  1387.   
  1388. }
  1389.  
  1390.  
  1391. /* This function returns definition positions of the unknown item. To handle
  1392.    scoping of local items, you can specify the position, where you found that 
  1393.    item.
  1394.    Note: scoping not implemented yet. The line_in is currently ignored
  1395.  
  1396.    item         ...   holds the name of the unknown item
  1397.    file_in      ...   file, where item was found (may be "")
  1398.    line_in      ...   line, where item was found (or -1)
  1399.                       only valid if a filename is specified
  1400.  
  1401.    file         ...   file, where item was defined
  1402.    line         ...   the line in the file, where item is defined
  1403.    module       ...   module, the file belongs to (or "")
  1404.  
  1405.    return:  
  1406.  
  1407.    RET_VAR           Return variable-position
  1408.  
  1409.    RET_FUNCT         Return function-position
  1410.  
  1411.    RET_TYPEDEF       Returns typedef
  1412.  
  1413.    RET_STRUCT        Returns struct-identifier
  1414.  
  1415.    RET_ENUM          Returns enum-type-identifier
  1416.  
  1417.    RET_UNION         Returns union-identifier
  1418.  
  1419.    RET_MACRO         Returns macro definition
  1420.                      Arguments: <macro>,<file>,<line>
  1421.  
  1422.        0        ...  O.K., function-info is stored in arguments
  1423.             RET_END  ...  No more functions found
  1424.             else     ...  error returned by get_brs_ret
  1425.                           error-message in macro/file
  1426.  */
  1427. short brs_what_is( char *item, char *file_in, long line_in,
  1428.                    char *file, long *line, char *module )
  1429. { int  server;
  1430.   char arg1[STRINGSIZE],
  1431.        arg2[STRINGSIZE],
  1432.        arg3[STRINGSIZE],
  1433.        arg4[STRINGSIZE];
  1434.   short  ret, flag;
  1435.   static short first = 1;
  1436.  
  1437.   /* NULL-Pointer in funct used for reset this function
  1438.    */
  1439.   if( !item )
  1440.    { first = 1;
  1441.      return( 0 );
  1442.     }
  1443.        
  1444.  
  1445.   if( first )    
  1446.     { /* First time this function is called: 
  1447.          send command to print all functions in project
  1448.        */
  1449.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  1450.        { return( ret );
  1451.         }
  1452.       
  1453.       send_brs_cmd( Server_ID, CMD_WHAT_IS, 0, item, file_in );
  1454.       first = 0;
  1455.      }
  1456.    
  1457.   do
  1458.    { ret = get_brs_ret( CMD_WHAT_IS, &server, &flag, arg1, arg2, arg3, arg4);
  1459.             
  1460.     } while( !ret );
  1461.   switch( ret )
  1462.    { case RET_MACRO:
  1463.           strcpy( file , arg2 );
  1464.           if( arg2[0] )
  1465.             *line = atoi( arg3 );
  1466.           break;
  1467.          
  1468.      case RET_FUNCT:
  1469.           strcpy( file , arg2 );
  1470.           if( arg2[0] )
  1471.             *line = atoi( arg3 );
  1472.           strcpy( module, arg4 );
  1473.           break;
  1474.       
  1475.      case RET_VAR:
  1476.           strcpy( file , arg2 );
  1477.           if( arg2[0] )
  1478.             *line = atoi( arg3 );
  1479.           strcpy( module, arg4 );
  1480.           break;
  1481.       
  1482.      case RET_STRUCT:
  1483.      case RET_UNION:
  1484.      case RET_ENUM:
  1485.      case RET_TYPEDEF:
  1486.           strcpy( file , arg2 );
  1487.           if( arg2[0] )
  1488.             *line = atoi( arg3 );
  1489.           break;
  1490.       
  1491.      case RET_ERROR:
  1492.           strcpy( file, arg1 );
  1493.           strcpy( module, arg2 );
  1494.           first = 1;
  1495.           return(ret);
  1496.           break;
  1497.       
  1498.      case RET_END:
  1499.           first = 1;
  1500.           return( ret );
  1501.           break;
  1502.          
  1503.      default:
  1504.           first = 1;
  1505.           return( ret );
  1506.           break;
  1507.     }
  1508.  
  1509.   return( ret );         
  1510.   
  1511. }
  1512.  
  1513.  
  1514. /* This function returns the position where the given macro
  1515.    is defined
  1516.  
  1517.    INPUT:
  1518.    macro        ...   target-macro
  1519.    file_in      ...   file, where target-macro is defined
  1520.                       may be "", if macro is just defined once
  1521.  
  1522.    OUTPUT 
  1523.    (if ret-value is 0:)
  1524.    file         ...   the file, where the macro is defined
  1525.    line         ...   linenumber, where macro is defined
  1526.    module       ...   module where file belongs to or ""
  1527.  
  1528.    (if ret-value if RET_ERROR)
  1529.    file         ...   Error message 1
  1530.    module       ...   Error message 2 (might be "")
  1531.  
  1532.    return:  0        ...  O.K., variable-info is stored in arguments
  1533.             else     ...  error returned by get_brs_ret
  1534.  */
  1535. short brs_get_macro_pos( char *macro, char *file_in,
  1536.                      char *file, long *line, char *module)
  1537. { int  server;
  1538.   char arg1[STRINGSIZE],
  1539.        arg2[STRINGSIZE],
  1540.        arg3[STRINGSIZE],
  1541.        arg4[STRINGSIZE];
  1542.   short  ret, flag;
  1543.  
  1544.   /* send command to retrieve position of function
  1545.    */
  1546.   if( (ret = brs_connect_server( Server_ID )) > 0 )
  1547.    { return( ret );
  1548.     }
  1549.       
  1550.   send_brs_cmd( Server_ID, CMD_MACRO_POS, 0, macro, file_in );
  1551.    
  1552.   ret = get_brs_ret( CMD_MACRO_POS, &server, &flag, arg1, arg2, arg3, arg4);
  1553.   switch( ret )
  1554.    { case RET_POS:
  1555.           strcpy( file , arg1 );
  1556.           if( arg2[0] )
  1557.             *line = atoi( arg2 );
  1558.           strcpy( module, arg3 );
  1559.           break;
  1560.  
  1561.      case RET_ERROR:
  1562.           strcpy( file, arg1 );
  1563.           strcpy( module, arg2 );
  1564.           return(ret);
  1565.           break;
  1566.  
  1567.      case RET_END:
  1568.           return( ret );
  1569.           break;
  1570.          
  1571.      default:
  1572.           return( ret );
  1573.           break;
  1574.     }
  1575.  
  1576.   return( 0 );         
  1577.   
  1578. }
  1579.  
  1580. /* This function returns the definition position of a given item
  1581.    which was found at given position (within an expression). It
  1582.    differs from the other brs_get_..._pos functions, because it
  1583.    provides a kind of scoping. It returns the position of the
  1584.    item which is valid in the context of the given position.
  1585.  
  1586.    It is also independend from the type of the item so it can be
  1587.    used for an identifier of an unknown type.
  1588.  
  1589.    INPUT:
  1590.    item         ...   item
  1591.    file_in      ...   file, where item was found
  1592.    line_in      ...   line, where item was found
  1593.  
  1594.    OUTPUT 
  1595.    (if ret-value is 0:)
  1596.    file         ...   the file, where the item is defined
  1597.    line         ...   linenumber, where item is defined
  1598.  
  1599.    (if ret-value if RET_ERROR)
  1600.    file         ...   Error message 1
  1601.  
  1602.    return:  0        ...  O.K., variable-info is stored in arguments
  1603.             else     ...  error returned by get_brs_ret
  1604.  */
  1605. short brs_get_item_pos( char *item, char *file_in, long line_in,
  1606.                         char *file, long *line)
  1607. { int  server;
  1608.   char arg1[STRINGSIZE],
  1609.        arg2[STRINGSIZE],
  1610.        arg3[STRINGSIZE],
  1611.        arg4[STRINGSIZE];
  1612.   short  ret, flag;
  1613.  
  1614.   /* send command to retrieve position of function
  1615.    */
  1616.   if( (ret = brs_connect_server( Server_ID )) > 0 )
  1617.    { return( ret );
  1618.     }
  1619.  
  1620.   if( strlen(item) + strlen(file_in) + 1 < STRINGSIZE )      
  1621.     { strcpy(arg1, file_in);
  1622.       strcat(arg1, "*"); /* seperator: '.' */
  1623.       strcat(arg1, item );
  1624.      }
  1625.   else
  1626.     { strcpy(file, "Arguments too long !");
  1627.       return(RET_ERROR);
  1628.      }
  1629.    
  1630.   sprintf(arg2, "%ld", line_in );
  1631.   send_brs_cmd( Server_ID, CMD_DEF_POS, 0, arg1, arg2 );
  1632.    
  1633.   ret = get_brs_ret( CMD_DEF_POS, &server, &flag, arg1, arg2, arg3, arg4);
  1634.   switch( ret )
  1635.    { case RET_POS:
  1636.           strcpy( file , arg1 );
  1637.           if( arg2[0] )
  1638.             *line = atoi( arg2 );
  1639.           break;
  1640.  
  1641.      case RET_ERROR:
  1642.           strcpy( file, arg1 );
  1643.           return(ret);
  1644.           break;
  1645.  
  1646.      case RET_END:
  1647.           strcpy( file, "" );
  1648.           return( ret );
  1649.           break;
  1650.          
  1651.      default:
  1652.           strcpy( file, "" );
  1653.           return( ret );
  1654.           break;
  1655.     }
  1656.  
  1657.   return( 0 );         
  1658.   
  1659. }
  1660.